!pip3 install opencv-python --quiet

import os
import numpy as np
import cv2
# from google.colab.patches import cv2_imshow # Uncomment if running in colab
import matplotlib.pyplot as plt
%matplotlib inline

# Save images path
# images_path = "drive/MyDrive/Vision por Computadora MISIS/Laboratorios/Taller1/images" # running in colab
images_path = "images/" # running locally
os.listdir(images_path)

['SPOT.png',
 'MUSCLE.png',
 'REGLE.png',
 'BUREAU.png',
 'CLEF.png',
 'ImagenBogota.png',
 'RONDELLE.png',
 'SCANNER.png',
 'TORAX.png',
 'AQUITAIN.png']

# definimos una función para leer y mostrar las imágenes
def read_and_show_image_gray_scale(image_path:str, colab:bool = False):
    """
    Lee una imagen en escala de grises y la muestra.
    
    Parámetros:
    image_path (str): Ruta de la imagen a leer.
    colab (bool): Indica si se está ejecutando en Google Colab.

    Retorna:
    image (numpy.ndarray): Imagen leída en escala de grises.
    """

    # leer la imagen
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

    # mostrar la imagen
    if colab:
        from google.colab.patches import cv2_imshow
        cv2_imshow(image)
    else:
        plt.imshow(image, cmap='gray', vmin=0, vmax=255)
        plt.axis('off')
        plt.show()

    return image

# lectura y carga de las imágenes
image_clef = read_and_show_image_gray_scale(os.path.join(images_path, 'CLEF.png'))

image_muscle = read_and_show_image_gray_scale(os.path.join(images_path, 'MUSCLE.png'))

# definimos una nueva función que calcula el histograma de una imagen
def calculate_histogram(image:np.ndarray, min_val:int = 0, max_val:int = 255, hist_title:str = "") -> np.ndarray:
    """
    Calcula el histograma de una imagen en escala de grises y grafica el resultado.

    Parámetros:
    image (numpy.ndarray): Imagen en escala de grises.
    min_val (int): Valor mínimo para el rango del histograma.
    max_val (int): Valor máximo para el rango del histograma.
    hist_title (str): Título para el gráfico del histograma.

    Retorna:
    histogram (numpy.ndarray): Histograma de la imagen.
    """
    # calcular el histograma
    histogram = cv2.calcHist([image], [0], None, [256], [min_val, max_val + 1])
    
    # plotear el histograma
    plt.plot(histogram)
    plt.xlim([min_val-10, max_val+10])
    if hist_title:
        plt.title(hist_title)
    plt.show()

    return histogram

clef_histogram = calculate_histogram(image_clef, hist_title="Histograma de CLEF")

muscle_histogram = calculate_histogram(image_muscle, hist_title="Histograma de MUSCLE")

print(image_clef.shape,image_muscle.shape)

(230, 256) (256, 256)

rondelle_image = read_and_show_image_gray_scale(os.path.join(images_path, 'RONDELLE.png'))
spot_image = read_and_show_image_gray_scale(os.path.join(images_path, 'SPOT.png'))

# comprobamos que las imagenes leídas sean de 8 bits
print(rondelle_image.dtype, spot_image.dtype)

uint8 uint8

# pasamos las imágenes a 16 bits haciendo una conversión
rondelle_image_16bit = rondelle_image.astype(np.uint16)
spot_image_16bit = spot_image.astype(np.uint16)

# comprobamos que las imagenes convertidas sean de 16 bits
print(rondelle_image_16bit.dtype, spot_image_16bit.dtype)

uint16 uint16

# visualizamos el histograma de ambas imagenes de 16 bits
rondelle_histogram_16bit = calculate_histogram(rondelle_image_16bit, hist_title="Histograma de RONDELLE (16 bits)")

# visualizamos el histograma de spot
spot_histogram_16bit = calculate_histogram(spot_image_16bit, hist_title="Histograma de SPOT (16 bits)")

# Adicionando rondelle a spot en 8 bits y en 16 bits
addition = cv2.add(rondelle_image, spot_image)

plt.imshow(addition, cmap='gray')
plt.title("Adición en 8 bits")
plt.axis('off')
plt.show()

addition_16bit = cv2.add(rondelle_image_16bit, spot_image_16bit)

plt.imshow(addition_16bit, cmap='gray')
plt.title("Adición en 16 bits")
plt.axis('off')
plt.show()

# visualizamos los histogramas de las imagenes resultantes de adición
addition_histogram = calculate_histogram(addition, hist_title="Histograma de Adición (8 bits)")
addition_16bit_histogram = calculate_histogram(addition_16bit, hist_title="Histograma de Adición (16 bits)", min_val=0, max_val=255*2)

# Sustracción rondelle - spot en 8 bits y en 16 bits
subtract_rondelle_minus_spot = cv2.subtract(rondelle_image, spot_image)

plt.imshow(subtract_rondelle_minus_spot, cmap='gray')
plt.title("Sustracción RONDELLE - SPOT en 8 bits")
plt.axis('off')
plt.show()

subtract_rondelle_minus_spot_16bit = cv2.subtract(rondelle_image_16bit, spot_image_16bit)
plt.imshow(subtract_rondelle_minus_spot_16bit, cmap='gray')
plt.title("Sustracción RONDELLE - SPOT en 16 bits")
plt.axis('off')
plt.show()

# visualizamos el histograma de ambas imagenes al hacer la sustracción
subtract_histogram = calculate_histogram(subtract_rondelle_minus_spot, hist_title="Histograma de Sustracción RONDELLE - SPOT (8 bits)")
subtract_16bit_histogram = calculate_histogram(subtract_rondelle_minus_spot_16bit, hist_title="Histograma de Sustracción RONDELLE - SPOT (16 bits)", min_val=0, max_val=255)

# Sustracción SPOT - RONDELLE en 8 bits y en 16 bits
subtract_spot_minus_rondelle = cv2.subtract(spot_image, rondelle_image)

plt.imshow(subtract_spot_minus_rondelle, cmap='gray')
plt.title("Sustracción SPOT - RONDELLE en 8 bits")
plt.axis('off')
plt.show()

subtract_spot_minus_rondelle_16bit = cv2.subtract(spot_image_16bit, rondelle_image_16bit)
plt.imshow(subtract_spot_minus_rondelle_16bit, cmap='gray')
plt.title("Sustracción SPOT - RONDELLE en 16 bits")
plt.axis('off')
plt.show()

# visualizamos el histograma de ambas imagenes al hacer la sustracción
subtract_histogram = calculate_histogram(subtract_spot_minus_rondelle, hist_title="Histograma de Sustracción SPOT - RONDELLE (8 bits)")
subtract_16bit_histogram = calculate_histogram(subtract_spot_minus_rondelle_16bit, hist_title="Histograma de Sustracción SPOT - RONDELLE (16 bits)", min_val=0, max_val=255)

# visualización de la imagen y del histograma
image_regle = read_and_show_image_gray_scale(os.path.join(images_path, "REGLE.png"))
regle_histogram = calculate_histogram(image_regle, hist_title="Histograma de REGLE")

# Negativo de la imagen
negative_regle = cv2.bitwise_not(image_regle)

plt.imshow(negative_regle, cmap='gray')
plt.title("Negativo de la imagen REGLE")
plt.axis('off')
plt.show()

# histogrtama del negativo
negative_regle_histogram = calculate_histogram(negative_regle, hist_title="Histograma del Negativo de REGLE")

# Expansión del histograma - contraste
# consiste en remapear los valores de la imagen para que ocupen todo el rango posible (0-255 para 8 bits)

# expansion de la imagen original
expanded_contrast_regle = cv2.normalize(image_regle, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX)

plt.imshow(expanded_contrast_regle, cmap='gray')
plt.title("Imagen con Contraste Expandido")
plt.axis('off')
plt.show()

# histograma del contraste expandido
expanded_contrast_histogram = calculate_histogram(expanded_contrast_regle, hist_title="Histograma de Contraste Expandido de REGLE")

# leer y visualizar la imagen
image_bureau = read_and_show_image_gray_scale(os.path.join(images_path, "BUREAU.png"))

# comprobar que la imagen tiene 8 bits
print(image_bureau.dtype)

uint8

# visualización de los planos binarios
def bit_plane_slicing(imagen: np.ndarray, k: int):
    # crear una nueva matriz tamaño de la imagen original, llena con el valor 2**k, equivalente a llenar de ceros todos los bits excepto el k-ésimo

    # nota: k va de 0 a 7, siendo 0 el bit menos significativo y 7 el más significativo
    plane = np.full((imagen.shape[0], imagen.shape[1]), 2 ** k, np.uint8)
    return cv2.bitwise_and(plane, imagen)

for i in range(8):
    print(f"Plano {i}")
    plane = bit_plane_slicing(image_bureau, i)
    plt.imshow(plane, cmap='gray')
    plt.title(f"Plano {i}")
    plt.axis('off')
    plt.show()

Plano 0

Plano 1

Plano 2

Plano 3

Plano 4

Plano 5

Plano 6

Plano 7

# modificar la cuantificación de la imagen
def image_quantization(imagen: np.ndarray, k: int):
    # funcion capaz de poner en cero el plano binario k de una imagen de 8 bits

    # primero se crea una nueva matriz tamaño de la imagen original, llena con el valor 255 - 2**k, equivalente a poner en cero el bit k-ésimo
    plane = np.full((imagen.shape[0], imagen.shape[1]), 255-2 ** k, np.uint8)
    return cv2.bitwise_and(plane, imagen)

# modificar la cuantificación de la imagen sobre 5, 3 y 1 bits respectivamente
num_bits = [5, 3, 1]
for bits in num_bits:
    bureau_copy = image_bureau.copy()
    colocar_en_cero = 8 - bits
    print("Bits a poner en cero:", colocar_en_cero)

    for i in range(colocar_en_cero): # coloca en cero los 8-k bits menos significativos
        bureau_copy = image_quantization(bureau_copy, i)

    plt.imshow(bureau_copy, cmap='gray')
    plt.title(f"Imagen cuantificada a {bits} bits")
    plt.axis('off')
    plt.show()

Bits a poner en cero: 3

Bits a poner en cero: 5

Bits a poner en cero: 7

# cargar imagenes spot y muscle
spot_image = read_and_show_image_gray_scale(os.path.join(images_path, 'SPOT.png'))
muscle_image = read_and_show_image_gray_scale(os.path.join(images_path, 'MUSCLE.png'))

# aplicar las operaciones lógicas AND, OR y XOR entre las dos imágenes
# primera parte: muscle - spot
muscle_and_spot = cv2.bitwise_and(muscle_image, spot_image)
muscle_or_spot = cv2.bitwise_or(muscle_image, spot_image)
muscle_xor_spot = cv2.bitwise_xor(muscle_image, spot_image)

# mostrar resultados
operations = {
    "AND": muscle_and_spot,
    "OR": muscle_or_spot,
    "XOR": muscle_xor_spot
}

for op_name, result_image in operations.items():
    plt.imshow(result_image, cmap='gray')
    plt.title(f"Muscle {op_name} Spot")
    plt.axis('off')
    plt.show()

# segunda parte: spot - muscle
spot_and_muscle = cv2.bitwise_and(spot_image, muscle_image)
spot_or_muscle = cv2.bitwise_or(spot_image, muscle_image)
spot_xor_muscle = cv2.bitwise_xor(spot_image, muscle_image)

# mostrar resultados
operations = {
    "AND": spot_and_muscle,
    "OR": spot_or_muscle,
    "XOR": spot_xor_muscle
}

for op_name, result_image in operations.items():
    plt.imshow(result_image, cmap='gray')
    plt.title(f"Spot {op_name} Muscle")
    plt.axis('off')
    plt.show()

# aplique la operación NOT sobre la imagen MUSCLE
# se puede realizar a través de la operación XOR con una imagen contraste de valor máximo 255 y se efectúa XOR con la imagen original

# crear una imagen de valor 255 del mismo tamaño que MUSCLE
constant_image = np.full(muscle_image.shape, 255, dtype=np.uint8)

# aplicar la operación XOR con MUSCLE
muscle_not = cv2.bitwise_xor(muscle_image, constant_image)

plt.imshow(muscle_not, cmap='gray')
plt.title("NOT de la imagen MUSCLE")
plt.axis('off')
plt.show()

# Ponga en cero en la imagen MUSCLE los 6 bits menos significativos de la zona marcada por SPOT, sin afectar el resto de la imagen.
# verifique que en la imagen resultado, la zona marcada solo toma los cuatro valores 192, 128, 64 y 0.

# primero debemos crear una máscara que seleccione la zona marcada por SPOT en MUSCLE
# esto lo podemos hacer utilizando la operación AND entre MUSCLE y SPOT
mask = cv2.bitwise_and(muscle_image, spot_image)

# a la mascara resultante le ponemos en cero los 6 bits menos significativos
mask_cuantified = mask.copy()
for i in range(6):
    mask_cuantified = image_quantization(mask_cuantified, i)

# seleccionamos la zona de MUSCLE que no está marcada por SPOT, aplicando NOT a SPOT y luego AND con MUSCLE
unchanged_muscle_zone = cv2.bitwise_and(muscle_image, cv2.bitwise_not(spot_image))

# combinamos ambas zonas para obtener la imagen final. Como las zonas no marcadas tienen 0s, se puede hacer con una operación OR
final_image = cv2.bitwise_or(mask_cuantified, unchanged_muscle_zone)

# mostrar la imagen final
plt.imshow(final_image, cmap='gray')
plt.title("Imagen MUSCLE con 6 bits menos significativos en zona SPOT puestos en cero")
plt.axis('off')
plt.show()

# verificar los valores únicos en la zona marcada por SPOT
unique_values = np.unique(final_image[spot_image == 255])
print("Valores únicos en la zona marcada por SPOT:", unique_values)

Valores únicos en la zona marcada por SPOT: [  0  64 128 192]

# generar una imagen de 256x256x1 con una malla 8x8
grid_image = np.full((256, 256), 255, dtype=np.uint8)
quadrant_size = 256//8

for i in range(0, 257, quadrant_size):
    pos = min(i, 254)

    grid_image[pos:pos+2, :] = 0
    grid_image[:, pos:pos+2] = 0

plt.imshow(grid_image, cmap='gray')
plt.title("Imagen de malla 8x8")
plt.axis('off')
plt.show()

print("Dimensiones de la imagen de malla:", grid_image.shape)

Dimensiones de la imagen de malla: (256, 256)

# redimensionar a 128x128 con Nearest Neighbor
imagen_r =  cv2.resize(grid_image, (128,128), interpolation=cv2.INTER_NEAREST)

plt.imshow(imagen_r, cmap='gray')
plt.title("Imagen de malla redimensionada a 128x128 con Nearest Neighbor")
plt.axis('off')
plt.show()

print("Dimensiones de la imagen redimensionada:", imagen_r.shape)

Dimensiones de la imagen redimensionada: (128, 128)

# seleccione tres técnicas de interpolación, incluyendo Nearest Neighbour.
interpolations = {
    "Nearest Neighbour": cv2.INTER_NEAREST,
    "Bilinear": cv2.INTER_LINEAR,
    "Bicubic": cv2.INTER_CUBIC
}
plt.figure(figsize=(15, 5))

# redimensionar la imagen de malla a 128x128 usando las tres técnicas
for i, (interp_name, interp_method) in enumerate(interpolations.items()):
    resized_image = cv2.resize(grid_image, (128, 128), interpolation=interp_method)
    
    plt.subplot(1, 3, i+1)
    plt.imshow(resized_image, cmap='gray')
    plt.title(f"Metodo {interp_name}")
    plt.axis('off')
    
    print(f"Dimensiones de la imagen redimensionada con {interp_name}:", resized_image.shape)

Dimensiones de la imagen redimensionada con Nearest Neighbour: (128, 128)
Dimensiones de la imagen redimensionada con Bilinear: (128, 128)
Dimensiones de la imagen redimensionada con Bicubic: (128, 128)

# repetir submestreando la imagen original a 100x100
interpolations = {
    "Nearest Neighbour": cv2.INTER_NEAREST,
    "Bilinear": cv2.INTER_LINEAR,
    "Bicubic": cv2.INTER_CUBIC
}
plt.figure(figsize=(15, 5))

# redimensionar la imagen de malla a 128x128 usando las tres técnicas
for i, (interp_name, interp_method) in enumerate(interpolations.items()):
    resized_image = cv2.resize(grid_image, (100, 100), interpolation=interp_method)
    
    plt.subplot(1, 3, i+1)
    plt.imshow(resized_image, cmap='gray')
    plt.title(f"Metodo {interp_name}")
    plt.axis('off')
    
    print(f"Dimensiones de la imagen redimensionada con {interp_name}:", resized_image.shape)

Dimensiones de la imagen redimensionada con Nearest Neighbour: (100, 100)
Dimensiones de la imagen redimensionada con Bilinear: (100, 100)
Dimensiones de la imagen redimensionada con Bicubic: (100, 100)

# cargar y visualizar la imagen TORAX
torax_image = read_and_show_image_gray_scale(os.path.join(images_path, "Torax.png"))

# submuestrear a dimensiones 34x31. Cambiar los diferentes interpoladores del filtro
interpolations = {
    "Original": None,
    "Nearest Neighbour": cv2.INTER_NEAREST,
    "Bilinear": cv2.INTER_LINEAR,
    "Bicubic": cv2.INTER_CUBIC
}

plt.figure(figsize=(15, 5))
for i, (interp_name, interp_method) in enumerate(interpolations.items()):
    if interp_method is None:
        resized_image = torax_image
    else:
        resized_image = cv2.resize(torax_image, (34, 31), interpolation=interp_method)
    
    plt.subplot(1, 4, i+1)
    plt.imshow(resized_image, cmap='gray')
    plt.title(f"Metodo {interp_name}")
    plt.axis('off')

# remuestreo a su tamaño original usando los mismos interpoladores
interpolations = {
    "Original": None,
    "Nearest Neighbour": cv2.INTER_NEAREST,
    "Bilinear": cv2.INTER_LINEAR,
    "Bicubic": cv2.INTER_CUBIC,
}

plt.figure(figsize=(15, 5))
for i, (interp_name, interp_method) in enumerate(interpolations.items()):
    if interp_method is None:
        resized_image = torax_image
        title = "Original"
    else:
        resized_image = cv2.resize(torax_image, (34, 31), interpolation=interp_method)
        resized_image = cv2.resize(resized_image, (torax_image.shape[1], torax_image.shape[0]), interpolation=interp_method)
        title = f"Metodo {interp_name}"
    
    plt.subplot(1, 4, i+1)
    plt.title(title)
    plt.imshow(resized_image, cmap='gray')
    plt.axis('off')

# Duplicar la dimensión (numero de filas y collumnas)
plt.figure(figsize=(15, 5))
for i, (interp_name, interp_method) in enumerate(interpolations.items()):
    if interp_method is None:
        resized_image = torax_image
        title = "Original"
    else:
        resized_image = cv2.resize(torax_image, (torax_image.shape[1]*2, torax_image.shape[0]*2), interpolation=interp_method)
        title = f"Metodo {interp_name} duplicado"
    
    plt.subplot(1, 4, i+1)
    plt.title(title)
    plt.imshow(resized_image, cmap='gray')
    plt.axis('off')

# genere una imagen de 256x256x1 con una rampa que vaya de negro a blanco de izquierda a derecha, visualice el resultado
rampa_image = np.tile(np.linspace(0, 255, 256, dtype=np.uint8), (256, 1))

# visualizar
plt.imshow(rampa_image, cmap='gray')
plt.title("Imagen de rampa")
plt.axis('off')
plt.show()

# cargue y visualice las imagenes de trabajo, junto con sus histogramas
aquitain_image = read_and_show_image_gray_scale(os.path.join(images_path, "AQUITAIN.png"))
histogrma_aquitain = calculate_histogram(aquitain_image, hist_title="Histograma AQUITAIN")

scanner_image = read_and_show_image_gray_scale(os.path.join(images_path, "SCANNER.png"))
histogrma_scanner = calculate_histogram(scanner_image, hist_title="Histograma SCANNER")

# Aplique una paleta de colores a cada una de estas 3 imágenes.  Visualice las imágenes resultado y las curvas. Utilice la imagen rampa para entender la distribución de los colores. Comente sus observaciones.

# usamos la funcion LUT para aplicar un mapa de color donde se mapea cada tono de gris a un componente específico
# para que sea en tres canales debemos tener una lookup table de 256x1x3

# creamos una look up table que pase de rojo a azul rápidamente hasta el valor de grises 40, y luego de azul a verde gradualmente desde 40 hasta 255
lut_color = np.zeros((256, 1, 3), dtype=np.uint8)
for i in range(256):
    if i <= 40: # separamos lut en dos partes, antes y despues del valor 40
        # multiplicamos por un factor de cambio
        val = int(i * (255 / 40))
        lut_color[i, 0, 2] = val # BLUE sube
        lut_color[i, 0, 0] = 255 - val # RED baja
    else:
        # ahora se hace el cambio de BLUE a RED 
        paso = i - 40
        val = int(paso * (255 / 215)) # multiplicamos nuevamente por un factor de cambio
        lut_color[i, 0, 2] = 255 - val # BLUE baja 
        lut_color[i, 0, 1] = i  # GREEN sube


# aplicamos el mapa de color a las tres imagenes
dstImage = cv2.LUT(cv2.merge([rampa_image , rampa_image , rampa_image ]), lut_color)
dstAquitain = cv2.LUT(cv2.merge([aquitain_image , aquitain_image , aquitain_image ]), lut_color)
dstScanner = cv2.LUT(cv2.merge([scanner_image , scanner_image , scanner_image ]), lut_color)

# visualizar las imagenes resultado
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(dstImage)
plt.title("Rampa con mapa de color")
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(dstAquitain)
plt.title("Aquitain con mapa de color")
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(dstScanner)
plt.title("Scanner con mapa de color")
plt.axis('off')

(np.float64(-0.5), np.float64(255.5), np.float64(255.5), np.float64(-0.5))

# creamos una función para plotear el histograma en RGB de una imagen
def calculate_histogram_rgb(image:np.ndarray, hist_title:str = "") -> np.ndarray:
    """
    Calcula el histograma de cada canal RGB de una imagen y grafica el resultado.

    Parámetros:
    image (numpy.ndarray): Imagen en formato RGB.
    hist_title (str): Título para el gráfico del histograma.

    Retorna:
    histogram (numpy.ndarray): Histograma RGB de la imagen.
    """
    # calcular el histograma para cada canal
    histogram_r = cv2.calcHist([image], [0], None, [256], [0, 256])
    histogram_g = cv2.calcHist([image], [1], None, [256], [0, 256])
    histogram_b = cv2.calcHist([image], [2], None, [256], [0, 256])
    
    # plotear el histograma
    plt.plot(histogram_r, color='r', label='Red Channel')
    plt.plot(histogram_g, color='g', label='Green Channel')
    plt.plot(histogram_b, color='b', label='Blue Channel')
    plt.xlim([-10, 265])
    plt.ylim([-1000, 70000])
    plt.legend()
    if hist_title:
        plt.title(hist_title)
    plt.show()

    return histogram_r, histogram_g, histogram_b

hists_rampa = calculate_histogram_rgb(dstImage, hist_title="Histograma RGB de Rampa con Mapa de Color")
hists_rampa = calculate_histogram_rgb(dstAquitain, hist_title="Histograma RGB de Aquitain con Mapa de Color")
hists_rampa = calculate_histogram_rgb(dstScanner, hist_title="Histograma RGB de Scanner con Mapa de Color")

# Expansión lineal del contraste en SCANNER
# mapear valores maximos y minimos en la imagen en grises de forma que tome todo el rango de 0 a 255
expanded_contrast_scanner= cv2.normalize(scanner_image, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX)

plt.imshow(expanded_contrast_scanner, cmap='gray')
plt.title("Imagen con Contraste Expandido SCANNER")
plt.axis('off')
plt.show()

# histograma del contraste expandido
expanded_contrast_histogram = calculate_histogram(expanded_contrast_scanner, hist_title="Histograma de Contraste Expandido de SCANNER")

# aplicar la misma paleta
expanded_contrast_scanner_color = cv2.LUT(cv2.merge([expanded_contrast_scanner , expanded_contrast_scanner , expanded_contrast_scanner ]), lut_color)

# visualizar
plt.imshow(expanded_contrast_scanner_color)
plt.title("SCANNER con Contraste Expandido y Mapa de Color")
plt.axis('off')
plt.show()

# histograma RGB
hists_expanded_scanner = calculate_histogram_rgb(expanded_contrast_scanner_color, hist_title="Histograma RGB de SCANNER con Contraste Expandido")

# Cargamos y visualizamos nuevamente la imagen MUSCLE y su histograma
muscle_image = read_and_show_image_gray_scale(os.path.join(images_path, 'MUSCLE.png'))

muscle_histogram =calculate_histogram(muscle_image, hist_title="Histograma de MUSCLE")

# Buscar punto de corte
valores_por_probar = [i for i in range(50, 91, 10)]

for i in valores_por_probar:
    # crear una mascara binaria, colocando todos los valores de tonos menores al valor de cambio por probar en False, y el resto en True
    mask = muscle_image <= i
    plt.imshow(mask, cmap='gray')
    plt.title(f"Máscara con punto de corte en {i}")
    plt.axis('off')
    plt.show()

# operacion and con el punto de corte en 90
mask_90 = muscle_image <= 90

# pasamos la mascara de binarios a 0-255
mask_90 = (mask_90.astype(np.uint8)) * 255

# calculamos el resultado como un OR
resultado = cv2.bitwise_or(muscle_image, mask_90)

# visualizamos
plt.imshow(resultado, cmap='gray')
plt.title(f"Resultado")
plt.axis('off')
plt.show()

# leer la imagen
imagen_bogota = read_and_show_image_gray_scale(os.path.join(images_path, "ImagenBogota.png"))

# Visualizaar las capas binarias de 0 a 7
for i in range(8):
    print(f"Plano {i}")
    plane = bit_plane_slicing(imagen_bogota, i)
    plt.imshow(plane, cmap='gray')
    plt.title(f"Plano {i}")
    plt.axis('off')
    plt.show()

Plano 0

Plano 1

Plano 2

Plano 3

Plano 4

Plano 5

Plano 6

Plano 7

imagen_completa = np.zeros(imagen_bogota.shape, dtype=np.uint8)
for i in range(0, 4):
    plane = bit_plane_slicing(imagen_bogota, i)
    # pasar el plano a 255 cuando no es 0
    plane[plane > 0] = 255
    imagen_completa = cv2.bitwise_or(imagen_completa, plane)
    
plt.imshow(imagen_completa, cmap='gray')
plt.title(f"Imagen con planos binarios 0 a 3 sumados")
plt.axis('off')
plt.show()

Taller 1: Operaciones elementales sobre imágenes¶

IMÁGENES Y VISIÓN - ISIS4825¶

Profesor: PhD Juan Pablo Reyes¶

Autores: Estefanía Laverde, Harvy Benitez.¶

1. Análisis del Histograma¶

2. Operaciones aritméticas¶

3. Negativo¶

4. Cuantificación¶

5. Operaciones lógicas¶

6. Interpolación¶

7. Modificación de la paleta de colores¶

8. Ejercicio de síntesis Taller 1¶

Ejercicio de bono¶